home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / suspend.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  10.2 KB  |  284 lines
  1. #ifndef _LINUX_SUSPEND_H
  2. #define _LINUX_SUSPEND_H
  3.  
  4. #if defined(CONFIG_X86) || defined(CONFIG_FRV) || defined(CONFIG_PPC32) || defined(CONFIG_PPC64)
  5. #include <asm/suspend.h>
  6. #endif
  7. #include <linux/swap.h>
  8. #include <linux/notifier.h>
  9. #include <linux/init.h>
  10. #include <linux/pm.h>
  11. #include <linux/mm.h>
  12. #include <asm/errno.h>
  13.  
  14. #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_VT) && defined(CONFIG_VT_CONSOLE)
  15. extern void pm_set_vt_switch(int);
  16. extern int pm_prepare_console(void);
  17. extern void pm_restore_console(void);
  18. #else
  19. static inline void pm_set_vt_switch(int do_switch)
  20. {
  21. }
  22.  
  23. static inline int pm_prepare_console(void)
  24. {
  25.     return 0;
  26. }
  27.  
  28. static inline void pm_restore_console(void)
  29. {
  30. }
  31. #endif
  32.  
  33. typedef int __bitwise suspend_state_t;
  34.  
  35. #define PM_SUSPEND_ON        ((__force suspend_state_t) 0)
  36. #define PM_SUSPEND_STANDBY    ((__force suspend_state_t) 1)
  37. #define PM_SUSPEND_MEM        ((__force suspend_state_t) 3)
  38. #define PM_SUSPEND_MAX        ((__force suspend_state_t) 4)
  39.  
  40. /**
  41.  * struct platform_suspend_ops - Callbacks for managing platform dependent
  42.  *    system sleep states.
  43.  *
  44.  * @valid: Callback to determine if given system sleep state is supported by
  45.  *    the platform.
  46.  *    Valid (ie. supported) states are advertised in /sys/power/state.  Note
  47.  *    that it still may be impossible to enter given system sleep state if the
  48.  *    conditions aren't right.
  49.  *    There is the %suspend_valid_only_mem function available that can be
  50.  *    assigned to this if the platform only supports mem sleep.
  51.  *
  52.  * @begin: Initialise a transition to given system sleep state.
  53.  *    @begin() is executed right prior to suspending devices.  The information
  54.  *    conveyed to the platform code by @begin() should be disregarded by it as
  55.  *    soon as @end() is executed.  If @begin() fails (ie. returns nonzero),
  56.  *    @prepare(), @enter() and @finish() will not be called by the PM core.
  57.  *    This callback is optional.  However, if it is implemented, the argument
  58.  *    passed to @enter() is redundant and should be ignored.
  59.  *
  60.  * @prepare: Prepare the platform for entering the system sleep state indicated
  61.  *    by @begin().
  62.  *    @prepare() is called right after devices have been suspended (ie. the
  63.  *    appropriate .suspend() method has been executed for each device) and
  64.  *    before the nonboot CPUs are disabled (it is executed with IRQs enabled).
  65.  *    This callback is optional.  It returns 0 on success or a negative
  66.  *    error code otherwise, in which case the system cannot enter the desired
  67.  *    sleep state (@enter() and @finish() will not be called in that case).
  68.  *
  69.  * @enter: Enter the system sleep state indicated by @begin() or represented by
  70.  *    the argument if @begin() is not implemented.
  71.  *    This callback is mandatory.  It returns 0 on success or a negative
  72.  *    error code otherwise, in which case the system cannot enter the desired
  73.  *    sleep state.
  74.  *
  75.  * @finish: Called when the system has just left a sleep state, right after
  76.  *    the nonboot CPUs have been enabled and before devices are resumed (it is
  77.  *    executed with IRQs enabled).
  78.  *    This callback is optional, but should be implemented by the platforms
  79.  *    that implement @prepare().  If implemented, it is always called after
  80.  *    @enter() (even if @enter() fails).
  81.  *
  82.  * @end: Called by the PM core right after resuming devices, to indicate to
  83.  *    the platform that the system has returned to the working state or
  84.  *    the transition to the sleep state has been aborted.
  85.  *    This callback is optional, but should be implemented by the platforms
  86.  *    that implement @begin(), but platforms implementing @begin() should
  87.  *    also provide a @end() which cleans up transitions aborted before
  88.  *    @enter().
  89.  *
  90.  * @recover: Recover the platform from a suspend failure.
  91.  *    Called by the PM core if the suspending of devices fails.
  92.  *    This callback is optional and should only be implemented by platforms
  93.  *    which require special recovery actions in that situation.
  94.  */
  95. struct platform_suspend_ops {
  96.     int (*valid)(suspend_state_t state);
  97.     int (*begin)(suspend_state_t state);
  98.     int (*prepare)(void);
  99.     int (*enter)(suspend_state_t state);
  100.     void (*finish)(void);
  101.     void (*end)(void);
  102.     void (*recover)(void);
  103. };
  104.  
  105. #ifdef CONFIG_SUSPEND
  106. /**
  107.  * suspend_set_ops - set platform dependent suspend operations
  108.  * @ops: The new suspend operations to set.
  109.  */
  110. extern void suspend_set_ops(struct platform_suspend_ops *ops);
  111. extern int suspend_valid_only_mem(suspend_state_t state);
  112.  
  113. /**
  114.  * arch_suspend_disable_irqs - disable IRQs for suspend
  115.  *
  116.  * Disables IRQs (in the default case). This is a weak symbol in the common
  117.  * code and thus allows architectures to override it if more needs to be
  118.  * done. Not called for suspend to disk.
  119.  */
  120. extern void arch_suspend_disable_irqs(void);
  121.  
  122. /**
  123.  * arch_suspend_enable_irqs - enable IRQs after suspend
  124.  *
  125.  * Enables IRQs (in the default case). This is a weak symbol in the common
  126.  * code and thus allows architectures to override it if more needs to be
  127.  * done. Not called for suspend to disk.
  128.  */
  129. extern void arch_suspend_enable_irqs(void);
  130.  
  131. extern int pm_suspend(suspend_state_t state);
  132. #else /* !CONFIG_SUSPEND */
  133. #define suspend_valid_only_mem    NULL
  134.  
  135. static inline void suspend_set_ops(struct platform_suspend_ops *ops) {}
  136. static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
  137. #endif /* !CONFIG_SUSPEND */
  138.  
  139. /* struct pbe is used for creating lists of pages that should be restored
  140.  * atomically during the resume from disk, because the page frames they have
  141.  * occupied before the suspend are in use.
  142.  */
  143. struct pbe {
  144.     void *address;        /* address of the copy */
  145.     void *orig_address;    /* original address of a page */
  146.     struct pbe *next;
  147. };
  148.  
  149. /* mm/page_alloc.c */
  150. extern void mark_free_pages(struct zone *zone);
  151.  
  152. /**
  153.  * struct platform_hibernation_ops - hibernation platform support
  154.  *
  155.  * The methods in this structure allow a platform to carry out special
  156.  * operations required by it during a hibernation transition.
  157.  *
  158.  * All the methods below, except for @recover(), must be implemented.
  159.  *
  160.  * @begin: Tell the platform driver that we're starting hibernation.
  161.  *    Called right after shrinking memory and before freezing devices.
  162.  *
  163.  * @end: Called by the PM core right after resuming devices, to indicate to
  164.  *    the platform that the system has returned to the working state.
  165.  *
  166.  * @pre_snapshot: Prepare the platform for creating the hibernation image.
  167.  *    Called right after devices have been frozen and before the nonboot
  168.  *    CPUs are disabled (runs with IRQs on).
  169.  *
  170.  * @finish: Restore the previous state of the platform after the hibernation
  171.  *    image has been created *or* put the platform into the normal operation
  172.  *    mode after the hibernation (the same method is executed in both cases).
  173.  *    Called right after the nonboot CPUs have been enabled and before
  174.  *    thawing devices (runs with IRQs on).
  175.  *
  176.  * @prepare: Prepare the platform for entering the low power state.
  177.  *    Called right after the hibernation image has been saved and before
  178.  *    devices are prepared for entering the low power state.
  179.  *
  180.  * @enter: Put the system into the low power state after the hibernation image
  181.  *    has been saved to disk.
  182.  *    Called after the nonboot CPUs have been disabled and all of the low
  183.  *    level devices have been shut down (runs with IRQs off).
  184.  *
  185.  * @leave: Perform the first stage of the cleanup after the system sleep state
  186.  *    indicated by @set_target() has been left.
  187.  *    Called right after the control has been passed from the boot kernel to
  188.  *    the image kernel, before the nonboot CPUs are enabled and before devices
  189.  *    are resumed.  Executed with interrupts disabled.
  190.  *
  191.  * @pre_restore: Prepare system for the restoration from a hibernation image.
  192.  *    Called right after devices have been frozen and before the nonboot
  193.  *    CPUs are disabled (runs with IRQs on).
  194.  *
  195.  * @restore_cleanup: Clean up after a failing image restoration.
  196.  *    Called right after the nonboot CPUs have been enabled and before
  197.  *    thawing devices (runs with IRQs on).
  198.  *
  199.  * @recover: Recover the platform from a failure to suspend devices.
  200.  *    Called by the PM core if the suspending of devices during hibernation
  201.  *    fails.  This callback is optional and should only be implemented by
  202.  *    platforms which require special recovery actions in that situation.
  203.  */
  204. struct platform_hibernation_ops {
  205.     int (*begin)(void);
  206.     void (*end)(void);
  207.     int (*pre_snapshot)(void);
  208.     void (*finish)(void);
  209.     int (*prepare)(void);
  210.     int (*enter)(void);
  211.     void (*leave)(void);
  212.     int (*pre_restore)(void);
  213.     void (*restore_cleanup)(void);
  214.     void (*recover)(void);
  215. };
  216.  
  217. #ifdef CONFIG_HIBERNATION
  218. /* kernel/power/snapshot.c */
  219. extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
  220. static inline void __init register_nosave_region(unsigned long b, unsigned long e)
  221. {
  222.     __register_nosave_region(b, e, 0);
  223. }
  224. static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
  225. {
  226.     __register_nosave_region(b, e, 1);
  227. }
  228. extern int swsusp_page_is_forbidden(struct page *);
  229. extern void swsusp_set_page_free(struct page *);
  230. extern void swsusp_unset_page_free(struct page *);
  231. extern unsigned long get_safe_page(gfp_t gfp_mask);
  232.  
  233. extern void hibernation_set_ops(struct platform_hibernation_ops *ops);
  234. extern int hibernate(void);
  235. #else /* CONFIG_HIBERNATION */
  236. static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
  237. static inline void swsusp_set_page_free(struct page *p) {}
  238. static inline void swsusp_unset_page_free(struct page *p) {}
  239.  
  240. static inline void hibernation_set_ops(struct platform_hibernation_ops *ops) {}
  241. static inline int hibernate(void) { return -ENOSYS; }
  242. #endif /* CONFIG_HIBERNATION */
  243.  
  244. #ifdef CONFIG_PM_SLEEP
  245. void save_processor_state(void);
  246. void restore_processor_state(void);
  247.  
  248. /* kernel/power/main.c */
  249. extern int register_pm_notifier(struct notifier_block *nb);
  250. extern int unregister_pm_notifier(struct notifier_block *nb);
  251.  
  252. #define pm_notifier(fn, pri) {                \
  253.     static struct notifier_block fn##_nb =            \
  254.         { .notifier_call = fn, .priority = pri };    \
  255.     register_pm_notifier(&fn##_nb);            \
  256. }
  257. #else /* !CONFIG_PM_SLEEP */
  258.  
  259. static inline int register_pm_notifier(struct notifier_block *nb)
  260. {
  261.     return 0;
  262. }
  263.  
  264. static inline int unregister_pm_notifier(struct notifier_block *nb)
  265. {
  266.     return 0;
  267. }
  268.  
  269. #define pm_notifier(fn, pri)    do { (void)(fn); } while (0)
  270. #endif /* !CONFIG_PM_SLEEP */
  271.  
  272. #ifndef CONFIG_HIBERNATION
  273. static inline void register_nosave_region(unsigned long b, unsigned long e)
  274. {
  275. }
  276. static inline void register_nosave_region_late(unsigned long b, unsigned long e)
  277. {
  278. }
  279. #endif
  280.  
  281. extern struct mutex pm_mutex;
  282.  
  283. #endif /* _LINUX_SUSPEND_H */
  284.